<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>rStar MCTS推理系统流程可视化</title>
    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f5f5f5;
            line-height: 1.6;
        }
        .container {
            max-width: 1200px;
            margin: 0 auto;
            background-color: white;
            padding: 30px;
            border-radius: 10px;
            box-shadow: 0 0 20px rgba(0,0,0,0.1);
        }
        h1 {
            color: #2c3e50;
            text-align: center;
            border-bottom: 3px solid #3498db;
            padding-bottom: 10px;
        }
        h2 {
            color: #34495e;
            margin-top: 30px;
            border-left: 4px solid #3498db;
            padding-left: 15px;
        }
        h3 {
            color: #7f8c8d;
            margin-top: 25px;
        }
        .mermaid {
            background-color: #fafafa;
            border: 1px solid #ddd;
            border-radius: 5px;
            padding: 20px;
            margin: 20px 0;
        }
        .flow-section {
            margin: 30px 0;
            padding: 20px;
            background-color: #f8f9fa;
            border-radius: 8px;
            border-left: 4px solid #28a745;
        }
        .function-detail {
            background-color: #e8f4f8;
            border: 1px solid #bee5eb;
            border-radius: 5px;
            padding: 15px;
            margin: 15px 0;
        }
        .code-block {
            background-color: #f8f9fa;
            border: 1px solid #e9ecef;
            border-radius: 4px;
            padding: 10px;
            font-family: 'Courier New', monospace;
            overflow-x: auto;
        }
        .voting-strategy {
            background-color: #fff3cd;
            border: 1px solid #ffeaa7;
            border-radius: 5px;
            padding: 15px;
            margin: 15px 0;
        }
        .action-type {
            background-color: #d1ecf1;
            border: 1px solid #bee5eb;
            border-radius: 5px;
            padding: 10px;
            margin: 10px 0;
        }
        .terminal-condition {
            background-color: #f8d7da;
            border: 1px solid #f5c6cb;
            border-radius: 5px;
            padding: 10px;
            margin: 10px 0;
        }
        .node-type {
            display: inline-block;
            background-color: #007bff;
            color: white;
            padding: 3px 8px;
            border-radius: 3px;
            font-size: 0.9em;
            margin: 2px;
        }
        .table-container {
            overflow-x: auto;
            margin: 20px 0;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin: 15px 0;
        }
        th, td {
            border: 1px solid #ddd;
            padding: 12px;
            text-align: left;
        }
        th {
            background-color: #f2f2f2;
            font-weight: bold;
        }
        .highlight {
            background-color: #fff3cd;
            padding: 2px 4px;
            border-radius: 3px;
        }
        .toc {
            background-color: #f8f9fa;
            border: 1px solid #dee2e6;
            border-radius: 5px;
            padding: 20px;
            margin: 20px 0;
        }
        .toc ul {
            list-style-type: none;
            padding-left: 0;
        }
        .toc li {
            margin: 5px 0;
        }
        .toc a {
            color: #007bff;
            text-decoration: none;
        }
        .toc a:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>rStar MCTS推理系统流程可视化</h1>
        
        <div class="toc">
            <h3>目录</h3>
            <ul>
                <li><a href="#overview">1. 系统概述</a></li>
                <li><a href="#main-flow">2. 主要流程图</a></li>
                <li><a href="#mcts-process">3. MCTS核心过程</a></li>
                <li><a href="#terminal-functions">4. 终端判断函数详解</a></li>
                <li><a href="#node-types">5. 节点类型与推理动作</a></li>
                <li><a href="#generator-functions">6. 生成器函数详解</a></li>
                <li><a href="#voting-strategy">7. 投票策略机制</a></li>
                <li><a href="#solution-selection">8. 解决方案选择</a></li>
                <li><a href="#function-calls">9. 函数调用关系</a></li>
                <li><a href="#uct-calculation">10. UCT计算与反向传播详解</a></li>
                <li><a href="#voting-mechanism">11. 投票机制详解</a></li>
                <li><a href="#node-values">12. 节点数值详解</a></li>
                <li><a href="#search-strategy">13. 搜索策略与权重调度</a></li>
                <li><a href="#performance-analysis">14. 性能分析与优化</a></li>
                <li><a href="#debugging-tips">15. 调试与可视化</a></li>
                <li><a href="#conclusion">16. 总结</a></li>
            </ul>
        </div>

        <section id="overview">
            <h2>1. 系统概述</h2>
            <p>rStar是一个基于MCTS的数学推理系统，通过蒙特卡洛树搜索算法探索推理空间，支持多种推理策略的组合使用。</p>
            
            <div class="function-detail">
                <h4>核心组件</h4>
                <ul>
                    <li><strong>Generator类</strong>：负责生成各种类型的推理节点</li>
                    <li><strong>Reasoning_MCTS_Node类</strong>：专门用于推理任务的MCTS节点</li>
                    <li><strong>search_for_answers函数</strong>：执行完整的MCTS搜索过程</li>
                    <li><strong>Evaluator类</strong>：答案评估和投票选择</li>
                </ul>
            </div>
        </section>

        <section id="main-flow">
            <h2>2. 主要流程图</h2>
            <div class="mermaid">
                graph TD
                    A[开始: search_for_answers] --> B[初始化MCTS搜索器]
                    B --> C[创建根节点 USER_QUESTION]
                    C --> D[开始MCTS Rollout循环]
                    D --> E[执行单轮MCTS: do_rollout]
                    E --> F[选择阶段: UCT选择]
                    F --> G[扩展阶段: find_children]
                    G --> H[模拟阶段: calculate_reward]
                    H --> I[反向传播: backpropagate]
                    I --> J[选择当前最佳解决方案]
                    J --> K{是否完成所有rollout?}
                    K -->|否| E
                    K -->|是| L[保存搜索树和轨迹]
                    L --> M[返回解决方案列表]
                    M --> N[结束]
                    
                    style A fill:#e1f5fe
                    style N fill:#e8f5e8
                    style E fill:#fff3e0
                    style J fill:#f3e5f5
            </div>
        </section>

        <section id="mcts-process">
            <h2>3. MCTS核心过程</h2>
            
            <h3>3.1 单轮Rollout详细流程</h3>
            <div class="mermaid">
                graph TD
                    A[开始Rollout] --> B[当前节点 = 根节点]
                    B --> C{节点是否为终端?}
                    C -->|是| D[计算奖励值]
                    C -->|否| E{节点是否已扩展?}
                    E -->|否| F[扩展节点: find_children]
                    E -->|是| G[UCT选择子节点]
                    F --> H[随机选择一个子节点]
                    G --> I[更新当前节点]
                    H --> I
                    I --> J{到达终端节点?}
                    J -->|否| C
                    J -->|是| K[计算终端奖励]
                    K --> L[反向传播更新统计]
                    D --> L
                    L --> M[返回终端节点]
                    
                    style A fill:#e3f2fd
                    style M fill:#e8f5e8
                    style F fill:#fff3e0
                    style K fill:#fce4ec
                    style C fill:#ffcdd2
                    style J fill:#ffcdd2
            </div>

            <div class="terminal-condition">
                <h4>⚠️ 重要区别：终端 vs 终端节点</h4>
                <div style="display: flex; gap: 20px; margin: 15px 0;">
                    <div style="flex: 1; background-color: #ffebee; border: 2px solid #f44336; border-radius: 8px; padding: 15px;">
                        <h5 style="color: #d32f2f; margin: 0 0 10px 0;">🔴 红框1：节点是否为终端？</h5>
                        <p><strong>函数</strong>：<code>is_terminal()</code></p>
                        <p><strong>判断条件</strong>：</p>
                        <ul style="margin: 5px 0;">
                            <li>深度 >= max_depth_allowed</li>
                            <li>OR 是有效叶子节点</li>
                        </ul>
                        <p><strong>作用</strong>：控制MCTS搜索是否继续扩展</p>
                        <p><strong>影响</strong>：决定是否停止搜索该分支</p>
                    </div>
                    <div style="flex: 1; background-color: #ffebee; border: 2px solid #f44336; border-radius: 8px; padding: 15px;">
                        <h5 style="color: #d32f2f; margin: 0 0 10px 0;">🔴 红框2：到达终端节点？</h5>
                        <p><strong>函数</strong>：<code>is_terminal()</code></p>
                        <p><strong>判断条件</strong>：与红框1相同</p>
                        <p><strong>作用</strong>：控制Rollout模拟是否结束</p>
                        <p><strong>影响</strong>：决定是否开始反向传播</p>
                    </div>
                </div>
                <div style="background-color: #e8f5e8; border: 2px solid #4caf50; border-radius: 8px; padding: 15px; margin: 15px 0;">
                    <h5 style="color: #2e7d32; margin: 0 0 10px 0;">✅ 结论：两个红框判断条件相同</h5>
                    <p><strong>实际上</strong>：这两个判断使用的是同一个函数 <code>is_terminal()</code></p>
                    <p><strong>区别仅在于</strong>：在MCTS流程中的不同位置调用，用于不同的控制逻辑</p>
                    <ul>
                        <li><strong>第一次调用</strong>：决定是否扩展节点（扩展阶段）</li>
                        <li><strong>第二次调用</strong>：决定是否结束模拟（模拟阶段）</li>
                    </ul>
                </div>
            </div>

            <h3>3.2 MCTS四个核心阶段详解</h3>
            
            <h4>3.2.1 选择阶段 (Selection)</h4>
            <div class="mermaid">
                graph TD
                    A[开始选择] --> B[当前节点 = 根节点]
                    B --> C{节点有子节点?}
                    C -->|否| D[选择该节点]
                    C -->|是| E{有未探索子节点?}
                    E -->|是| F[随机选择未探索子节点]
                    E -->|否| G[计算所有子节点UCT值]
                    G --> H[选择UCT值最大的子节点]
                    H --> I[更新当前节点]
                    I --> J{选中节点是叶子?}
                    J -->|否| C
                    J -->|是| K[返回选择路径]
                    D --> K
                    F --> K
                    
                    style A fill:#e3f2fd
                    style K fill:#e8f5e8
                    style G fill:#fff3e0
                    style H fill:#f3e5f5
            </div>

            <div class="function-detail">
                <h4>UCT公式详解</h4>
                <div class="code-block">
UCT(节点) = Q(节点)/N(节点) + C × √(ln(N(父节点))/N(节点))

其中：
- Q(节点): 节点累积奖励值
- N(节点): 节点访问次数  
- N(父节点): 父节点访问次数
- C: 探索权重参数 (mcts_exploration_weight)

特殊情况：
- 根节点: UCT = 666 (特殊标识)
- 未探索节点: UCT = 999 (最高优先级)
- 已探索节点: 按公式计算
                </div>
            </div>

            <h4>3.2.2 扩展阶段 (Expansion)</h4>
            <div class="mermaid">
                graph TD
                    A[扩展阶段开始] --> B{节点已扩展?}
                    B -->|是| C[跳过扩展]
                    B -->|否| D{节点是终端?}
                    D -->|是| E[标记为已探索]
                    D -->|否| F[调用find_children]
                    F --> G[根据节点类型执行推理动作]
                    G --> H[A1: 一步思考]
                    G --> I[A2: 直接答案]
                    G --> J[A3: 子问题分解]
                    G --> K[A4: 重新回答]
                    G --> L[A5: 问题重述]
                    H --> M[创建OST_STEP子节点]
                    I --> N[创建DIRECT_ANSWER子节点]
                    J --> O[创建SUBQUESTION子节点]
                    K --> P[创建RE_SUBANSWER子节点]
                    L --> Q[创建REPHRASED_USER_QUESTION子节点]
                    M --> R[子节点列表]
                    N --> R
                    O --> R
                    P --> R
                    Q --> R
                    R --> S[存储父子关系]
                    
                    style A fill:#e3f2fd
                    style S fill:#e8f5e8
                    style G fill:#fff3e0
                    style C fill:#ffcdd2
                    style E fill:#ffcdd2
            </div>

            <div class="function-detail">
                <h4>推理动作详细说明</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>动作</th>
                            <th>节点类型</th>
                            <th>生成数量</th>
                            <th>功能描述</th>
                            <th>API调用</th>
                        </tr>
                        <tr>
                            <td>A1</td>
                            <td>OST_STEP</td>
                            <td>num_a1_steps (3)</td>
                            <td>生成单步推理思考</td>
                            <td>低成本</td>
                        </tr>
                        <tr>
                            <td>A2</td>
                            <td>DIRECT_ANSWER</td>
                            <td>mcts_num_last_votes (32)</td>
                            <td>直接回答问题</td>
                            <td>高成本</td>
                        </tr>
                        <tr>
                            <td>A3</td>
                            <td>SUBQUESTION</td>
                            <td>num_subquestions (3)</td>
                            <td>分解为子问题</td>
                            <td>中等成本</td>
                        </tr>
                        <tr>
                            <td>A4</td>
                            <td>RE_SUBANSWER</td>
                            <td>num_votes (10)</td>
                            <td>重新回答子问题</td>
                            <td>低成本</td>
                        </tr>
                        <tr>
                            <td>A5</td>
                            <td>REPHRASED_USER_QUESTION</td>
                            <td>1</td>
                            <td>重新表述问题</td>
                            <td>最低成本</td>
                        </tr>
                    </table>
                </div>
            </div>

            <h4>3.2.3 模拟阶段 (Simulation)</h4>
            <div class="mermaid">
                graph TD
                    A[模拟阶段开始] --> B[当前节点 = 扩展节点]
                    B --> C{节点是终端?}
                    C -->|是| D[模拟结束]
                    C -->|否| E{节点有子节点?}
                    E -->|否| F[为节点创建子节点]
                    E -->|是| G[随机选择一个子节点]
                    F --> H[随机选择新创建的子节点]
                    G --> I[更新当前节点]
                    H --> I
                    I --> J[添加到模拟路径]
                    J --> C
                    D --> K[返回模拟路径]
                    
                    style A fill:#e3f2fd
                    style K fill:#e8f5e8
                    style F fill:#fff3e0
                    style G fill:#f3e5f5
                    style D fill:#ffcdd2
            </div>

            <div class="function-detail">
                <h4>模拟策略说明</h4>
                <ul>
                    <li><strong>随机选择</strong>：在每个非终端节点随机选择子节点</li>
                    <li><strong>快速推进</strong>：不进行复杂的评估，快速到达终端状态</li>
                    <li><strong>路径记录</strong>：记录模拟过程中访问的所有节点</li>
                    <li><strong>终端判断</strong>：使用is_terminal()判断是否到达终端</li>
                </ul>
            </div>

            <h4>3.2.4 反向传播阶段 (Backpropagation)</h4>
            <div class="mermaid">
                graph TD
                    A[反向传播开始] --> B[计算终端节点奖励]
                    B --> C[获取完整路径]
                    C --> D[从终端节点向根节点传播]
                    D --> E[遍历路径中的每个节点]
                    E --> F{节点需要跳过?}
                    F -->|是| G[跳过统计更新]
                    F -->|否| H[更新Q值: Q += reward]
                    H --> I[更新N值: N += 1]
                    I --> J[添加到已探索集合]
                    J --> K{还有未处理节点?}
                    G --> K
                    K -->|是| L[移动到父节点]
                    K -->|否| M[反向传播完成]
                    L --> E
                    
                    style A fill:#e3f2fd
                    style M fill:#e8f5e8
                    style B fill:#fff3e0
                    style H fill:#f3e5f5
                    style I fill:#f3e5f5
                    style F fill:#ffcdd2
            </div>

            <div class="function-detail">
                <h4>🎯 奖励计算与传播机制详解</h4>
                <div class="voting-strategy">
                    <h4>1. 终端节点奖励计算</h4>
                    <div class="code-block">
def calculate_reward(self):
    """计算节点奖励值"""
    if self.is_valid_leaf_node():
        return self.node_value  # 返回置信度 (0-1)
    else:
        return 0  # 非有效叶子节点奖励为0
                    </div>
                    
                    <h4>2. 奖励传播规则</h4>
                    <ul>
                        <li><strong>相同奖励传播</strong>：终端节点的奖励值会完全传播给路径上的所有参与节点</li>
                        <li><strong>累积更新机制</strong>：每个参与节点的Q值 += 奖励值，N值 += 1</li>
                        <li><strong>平均奖励计算</strong>：UCT计算中使用 Q/N 作为平均奖励</li>
                        <li><strong>奖励值不变性</strong>：同一条路径上的所有节点都获得相同的奖励值</li>
                    </ul>
                    
                    <h4>3. 具体传播过程示例</h4>
                    <div class="code-block">
# 假设路径：根节点 → 子问题节点 → 直接答案节点
# 终端节点奖励：0.8 (答案置信度)

理论上的传播过程：
1. 直接答案节点: Q += 0.8, N += 1 (skip_backprop=False)
2. 子问题节点: Q += 0.8, N += 1 (skip_backprop=False)
3. 根节点: 跳过更新 (skip_backprop=True)

期望结果：
- 直接答案节点: Q=0.8, N=1, 平均奖励=0.8
- 子问题节点: Q=0.8, N=1, 平均奖励=0.8
- 根节点: Q=0, N=0 (未更新)

实际的传播过程（当前实现）：
1. 直接答案节点: Q += 0.8, N += 1
2. 子问题节点: Q += 0.8, N += 1  
3. 根节点: Q += 0.8, N += 1 (未检查skip_backprop)

实际结果：
- 直接答案节点: Q=0.8, N=1, 平均奖励=0.8
- 子问题节点: Q=0.8, N=1, 平均奖励=0.8
- 根节点: Q=0.8, N=1, 平均奖励=0.8 (意外更新)
                    </div>
                    
                    <h4>4. 多次rollout的累积效果</h4>
                    <div class="code-block">
# 假设经过3次rollout，每次终端奖励都是0.8
# 对于参与反向传播的节点：

第1次rollout后: Q=0.8, N=1, 平均奖励=0.8
第2次rollout后: Q=1.6, N=2, 平均奖励=0.8
第3次rollout后: Q=2.4, N=3, 平均奖励=0.8

关键观察：
- Q值累积增长，N值计数增长
- 平均奖励(Q/N)保持稳定，反映一致的解决方案质量
- 如果某次rollout奖励不同，平均奖励会相应调整
                    </div>
                </div>
            </div>

            <div class="function-detail">
                <h4>🔄 反向传播的完整流程图</h4>
                <div class="mermaid">
                    graph TD
                        A["路径: 根→子问题→直接答案"] --> B["终端节点奖励=0.8"]
                        B --> C["反向遍历路径"]
                        C --> D["直接答案节点"]
                        D --> E{"skip_backprop?"}
                        E -->|否| F["Q += 0.8, N += 1"]
                        F --> G["子问题节点"]
                        G --> H{"skip_backprop?"}
                        H -->|否| I["Q += 0.8, N += 1"]
                        I --> J["根节点"]
                        J --> K{"skip_backprop?"}
                        K -->|是| L["跳过更新"]
                        K -->|否| M["Q += 0.8, N += 1"]
                        L --> N["传播完成"]
                        M --> N
                        
                        style A fill:#e3f2fd
                        style B fill:#fff3e0
                        style F fill:#e8f5e8
                        style I fill:#e8f5e8
                        style L fill:#ffcdd2
                        style M fill:#ffeb3b
                        style N fill:#c8e6c9
                </div>
                
                <h4>📝 流程图说明</h4>
                <ul>
                    <li><strong>黄色节点</strong>：当前实现中实际发生的行为（根节点也被更新）</li>
                    <li><strong>红色节点</strong>：理论设计中应该发生的行为（根节点跳过更新）</li>
                    <li><strong>绿色节点</strong>：正常的统计更新操作</li>
                </ul>
            </div>

            <div class="function-detail">
                <h4>📊 不同节点类型的奖励机制</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>节点类型</th>
                            <th>奖励计算</th>
                            <th>skip_backprop</th>
                            <th>奖励来源</th>
                            <th>理论传播影响</th>
                            <th>实际传播影响</th>
                        </tr>
                        <tr>
                            <td><span class="node-type">DIRECT_ANSWER</span></td>
                            <td>node_value (置信度)</td>
                            <td>False</td>
                            <td>投票选择的答案置信度</td>
                            <td>作为奖励源头，影响整条路径</td>
                            <td>✅ 按预期工作</td>
                        </tr>
                        <tr>
                            <td><span class="node-type">SUBQUESTION</span></td>
                            <td>node_value (子答案置信度)</td>
                            <td>False</td>
                            <td>子答案的投票置信度</td>
                            <td>接收并传播奖励</td>
                            <td>✅ 按预期工作</td>
                        </tr>
                        <tr>
                            <td><span class="node-type">OST_STEP</span></td>
                            <td>0 (中间步骤)</td>
                            <td>False</td>
                            <td>无直接奖励</td>
                            <td>接收并传播奖励</td>
                            <td>✅ 按预期工作</td>
                        </tr>
                        <tr>
                            <td><span class="node-type">RE_SUBANSWER</span></td>
                            <td>node_value (重新回答置信度)</td>
                            <td>False</td>
                            <td>重新回答的投票置信度</td>
                            <td>接收并传播奖励</td>
                            <td>✅ 按预期工作</td>
                        </tr>
                        <tr>
                            <td><span class="node-type">USER_QUESTION</span></td>
                            <td>0 (根节点)</td>
                            <td>True</td>
                            <td>无奖励</td>
                            <td>不参与统计更新</td>
                            <td>⚠️ 实际被更新</td>
                        </tr>
                        <tr>
                            <td><span class="node-type">REPHRASED_USER_QUESTION</span></td>
                            <td>0 (重述节点)</td>
                            <td>True</td>
                            <td>无奖励</td>
                            <td>不参与统计更新</td>
                            <td>⚠️ 实际被更新</td>
                        </tr>
                    </table>
                </div>
            </div>
            
            <div class="function-detail">
                <h4>🎯 关键问题解答</h4>
                <div class="voting-strategy">
                    <h4>Q1: 每个节点如何计算奖励？</h4>
                    <p><strong>答案</strong>：只有路径的<strong>终端节点</strong>才计算奖励，其他节点接收传播的奖励。</p>
                    <ul>
                        <li>有效叶子节点：返回node_value（置信度0-1）</li>
                        <li>非有效叶子节点：返回0</li>
                        <li>中间节点：不计算奖励，只接收传播</li>
                    </ul>
                    
                    <h4>Q2: 如何传播和叠加奖励？</h4>
                    <p><strong>答案</strong>：<strong>相同奖励值</strong>传播给路径上的所有节点，每个节点<strong>累积叠加</strong>。</p>
                    <ul>
                        <li>传播机制：终端节点的奖励值完全传播给路径上每个节点</li>
                        <li>叠加方式：Q[node] += reward（累积），N[node] += 1（计数）</li>
                        <li>多次rollout：每次都会累积，Q值越来越大，N值越来越大</li>
                    </ul>
                    
                    <h4>Q3: 终端节点的奖励是否让整条路径所有节点都获得相同奖励？</h4>
                    <p><strong>答案</strong>：<strong>是的</strong>，这是MCTS反向传播的核心机制。</p>
                    <ul>
                        <li>奖励值相同：路径上所有参与节点都获得相同的奖励值</li>
                        <li>累积效果相同：如果一个节点被多次访问，每次都累积相同的奖励</li>
                        <li>平均奖励趋同：对于经常一起出现的节点，平均奖励(Q/N)会趋于相似</li>
                    </ul>
                    
                    <h4>Q4: 为什么要这样设计？</h4>
                    <p><strong>答案</strong>：这是MCTS算法的核心设计原理。</p>
                    <ul>
                        <li><strong>路径价值评估</strong>：一条路径的价值由其终端结果决定</li>
                        <li><strong>信用分配</strong>：路径上的每个决策都对最终结果有贡献</li>
                        <li><strong>探索平衡</strong>：好的路径会被更多探索，差的路径会被逐渐放弃</li>
                        <li><strong>收敛保证</strong>：随着访问次数增加，节点价值估计会收敛到真实价值</li>
                    </ul>
                </div>
            </div>

            <div class="function-detail">
                <h4>🧮 UCT值计算中的奖励使用</h4>
                <div class="code-block">
UCT = Q/N + C × √(ln(N_parent)/N)
     ↑
   平均奖励部分

示例计算：
- 节点A: Q=2.4, N=3 → 平均奖励 = 2.4/3 = 0.8
- 节点B: Q=1.6, N=2 → 平均奖励 = 1.6/2 = 0.8
- 节点C: Q=0.9, N=1 → 平均奖励 = 0.9/1 = 0.9

UCT选择：节点C (最高平均奖励 + 探索奖励)
                </div>
            </div>

            <div class="function-detail">
                <h4>⚠️ 重要发现：当前实现与理论设计的差异</h4>
                <div class="terminal-condition">
                    <h4>🔍 代码分析发现</h4>
                    <p>通过分析<code>MCTS_backbone.py</code>的<code>_backpropagate</code>方法，发现：</p>
                    <ul>
                        <li><strong>当前实现未检查skip_backprop</strong>：所有路径节点都会被更新统计</li>
                        <li><strong>理论设计意图</strong>：skip_backprop应该控制哪些节点参与统计更新</li>
                        <li><strong>实际行为</strong>：根节点(USER_QUESTION)和重述节点(REPHRASED_USER_QUESTION)也会累积奖励值</li>
                        <li><strong>影响分析</strong>：这可能导致根节点获得不应有的统计信息，但不影响子节点选择</li>
                    </ul>
                    
                    <h4>🛠️ 理想的实现应该是</h4>
                    <div class="code-block">
def _backpropagate(self, path: List[MCTS_Node]):
    """
    反向传播阶段：将奖励值传播回路径上的所有节点
    理想实现应该检查skip_backprop标志
    """
    leaf = path[-1]
    reward = leaf.calculate_reward()
    for node in reversed(path):
        if not node.skip_backprop():  # 检查是否跳过统计更新
            self.Q[node] += reward
            self.N[node] += 1
        self.explored_nodes.add(node)  # 所有节点都加入已探索集合
                    </div>
                    
                    <h4>🔄 当前实际实现</h4>
                    <div class="code-block">
def _backpropagate(self, path: List[MCTS_Node]):
    """
    当前实现：所有节点都会被更新
    """
    leaf = path[-1]
    reward = leaf.calculate_reward()
    for node in reversed(path):
        self.Q[node] += reward      # 所有节点都累积奖励
        self.N[node] += 1          # 所有节点都增加访问计数
        self.explored_nodes.add(node)
                    </div>
                    
                    <h4>💡 实际影响评估</h4>
                    <ul>
                        <li><strong>对搜索效果的影响</strong>：相对有限，因为根节点通常不参与UCT选择</li>
                        <li><strong>对统计准确性的影响</strong>：根节点获得了不应有的Q/N统计</li>
                        <li><strong>对算法正确性的影响</strong>：不影响核心MCTS逻辑，但偏离了理论设计</li>
                    </ul>
                </div>
            </div>

            <div class="function-detail">
                <h4>奖励计算详解</h4>
                <div class="code-block">
def calculate_reward(self):
    """计算节点奖励值"""
    if self.is_valid_leaf_node():
        return self.node_value  # 返回置信度 (0-1)
    else:
        return 0  # 非有效叶子节点奖励为0

奖励标准化处理：
reward = min(0, reward_value) + 1
# 目的：确保所有奖励值至少为1，避免0奖励影响UCT计算
                </div>
            </div>

            <div class="function-detail">
                <h4>节点统计更新</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>统计项</th>
                            <th>更新规则</th>
                            <th>含义</th>
                            <th>用途</th>
                        </tr>
                        <tr>
                            <td>Q值</td>
                            <td>Q[node] += reward</td>
                            <td>累积奖励值</td>
                            <td>UCT计算的平均奖励部分</td>
                        </tr>
                        <tr>
                            <td>N值</td>
                            <td>N[node] += 1</td>
                            <td>访问次数</td>
                            <td>UCT计算的探索部分</td>
                        </tr>
                        <tr>
                            <td>已探索集合</td>
                            <td>explored_nodes.add(node)</td>
                            <td>节点探索状态</td>
                            <td>选择阶段的决策依据</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h4>跳过反向传播的节点类型</h4>
                <div class="voting-strategy">
                    <h4>🚫 跳过反向传播的节点</h4>
                    <ul>
                        <li><strong>USER_QUESTION</strong>：根节点，不需要统计更新</li>
                        <li><strong>REPHRASED_USER_QUESTION</strong>：问题重述节点，不提供直接解决方案</li>
                    </ul>
                    
                    <h4>✅ 参与反向传播的节点</h4>
                    <ul>
                        <li><strong>DIRECT_ANSWER</strong>：直接答案节点，需要评估答案质量</li>
                        <li><strong>SUBQUESTION</strong>：子问题节点，需要评估分解效果</li>
                        <li><strong>RE_SUBANSWER</strong>：重新回答节点，需要评估新答案质量</li>
                        <li><strong>OST_STEP</strong>：思考步骤节点，需要评估推理价值</li>
                    </ul>
                </div>
            </div>

            <h3>3.3 权重调度策略</h3>
            <div class="mermaid">
                graph LR
                    A[权重调度策略] --> B[const: 恒定权重]
                    A --> C[exp: 指数衰减]
                    A --> D[lin: 线性衰减]
                    
                    B --> B1[C = exploration_weight]
                    C --> C1[C = exploration_weight × 0.1^(t/T)]
                    D --> D1[C = exploration_weight × (1 - 0.9×t/T)]
                    
                    B1 --> E[探索-利用平衡]
                    C1 --> E
                    D1 --> E
                    
                    style A fill:#e3f2fd
                    style E fill:#e8f5e8
                    style B fill:#fff3e0
                    style C fill:#f3e5f5
                    style D fill:#fce4ec
            </div>

            <div class="function-detail">
                <h4>权重调度对搜索行为的影响</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>策略</th>
                            <th>初期行为</th>
                            <th>后期行为</th>
                            <th>适用场景</th>
                        </tr>
                        <tr>
                            <td>const</td>
                            <td>平衡探索利用</td>
                            <td>持续平衡</td>
                            <td>稳定搜索</td>
                        </tr>
                        <tr>
                            <td>exp</td>
                            <td>广泛探索</td>
                            <td>快速收敛</td>
                            <td>快速决策</td>
                        </tr>
                        <tr>
                            <td>lin</td>
                            <td>广泛探索</td>
                            <td>平滑收敛</td>
                            <td>渐进优化</td>
                        </tr>
                    </table>
                </div>
            </div>

            <h3>3.4 完整的MCTS搜索循环</h3>
            <div class="mermaid">
                graph TD
                    A[初始化MCTS搜索器] --> B[创建根节点]
                    B --> C[开始Rollout循环]
                    C --> D[执行do_rollout]
                    D --> E[Selection: 选择节点]
                    E --> F[Expansion: 扩展节点]
                    F --> G[Simulation: 模拟到终端]
                    G --> H[Backpropagation: 反向传播]
                    H --> I[收集解决方案]
                    I --> J[选择最佳解决方案]
                    J --> K{完成所有rollout?}
                    K -->|否| L[rollout_id += 1]
                    L --> D
                    K -->|是| M[保存搜索树]
                    M --> N[返回最终解决方案]
                    
                    style A fill:#e3f2fd
                    style N fill:#e8f5e8
                    style D fill:#fff3e0
                    style I fill:#f3e5f5
                    style J fill:#fce4ec
            </div>

            <div class="function-detail">
                <h4>搜索循环中的关键统计</h4>
                <div class="voting-strategy">
                    <h4>📊 每轮Rollout统计</h4>
                    <ul>
                        <li><strong>解决方案节点数量</strong>：当前搜索树中的有效解决方案数</li>
                        <li><strong>API调用次数</strong>：累积的模型推理调用次数</li>
                        <li><strong>Token使用量</strong>：累积的Token消耗统计</li>
                        <li><strong>搜索树深度</strong>：当前搜索树的最大深度</li>
                        <li><strong>节点总数</strong>：搜索树中的总节点数量</li>
                    </ul>
                    
                    <h4>🎯 终止条件</h4>
                    <ul>
                        <li><strong>完成所有rollout</strong>：达到预设的num_rollouts轮数</li>
                        <li><strong>早期停止</strong>：可选的置信度阈值机制</li>
                        <li><strong>资源限制</strong>：达到最大API调用次数或时间限制</li>
                    </ul>
                </div>
            </div>

            <h3>3.5 终端内容判断 vs 终端节点判断</h3>
            <div class="terminal-condition">
                <h4>🔍 深入分析：终端内容的判断</h4>
                <div style="display: flex; gap: 20px; margin: 15px 0;">
                    <div style="flex: 1; background-color: #fff3e0; border: 2px solid #ff9800; border-radius: 8px; padding: 15px;">
                        <h5 style="color: #f57c00; margin: 0 0 10px 0;">🟡 终端子问题判断</h5>
                        <p><strong>函数</strong>：<code>reach_terminal_subquestion()</code></p>
                        <p><strong>判断条件</strong>：</p>
                        <ul style="margin: 5px 0;">
                            <li>包含"Now we can answer"</li>
                            <li>OR 包含原问题核心部分</li>
                        </ul>
                        <p><strong>作用</strong>：判断子问题内容是否回到原问题</p>
                        <p><strong>用途</strong>：</p>
                        <ul>
                            <li>投票数量决策（32 vs 10）</li>
                            <li>有效解决方案节点识别</li>
                        </ul>
                    </div>
                    <div style="flex: 1; background-color: #fff3e0; border: 2px solid #ff9800; border-radius: 8px; padding: 15px;">
                        <h5 style="color: #f57c00; margin: 0 0 10px 0;">🟡 终端思考步骤判断</h5>
                        <p><strong>函数</strong>：<code>reach_terminal_ost_step()</code></p>
                        <p><strong>判断条件</strong>：</p>
                        <ul style="margin: 5px 0;">
                            <li>包含"answer is"</li>
                        </ul>
                        <p><strong>作用</strong>：判断思考步骤是否得出最终答案</p>
                        <p><strong>用途</strong>：</p>
                        <ul>
                            <li>有效解决方案节点识别</li>
                            <li>推理轨迹完整性验证</li>
                        </ul>
                    </div>
                </div>
            </div>

            <h3>3.6 节点扩展过程</h3>
            <div class="mermaid">
                graph TD
                    A[find_children调用] --> B{子节点是否已存在?}
                    B -->|是| C[返回现有子节点]
                    B -->|否| D[调用_create_children]
                    D --> E[根据节点类型确定可执行动作]
                    E --> F[执行推理动作A1-A5]
                    F --> G[生成子节点列表]
                    G --> H[设置rollout_id]
                    H --> I[返回子节点列表]
                    
                    style A fill:#e3f2fd
                    style D fill:#fff3e0
                    style F fill:#f3e5f5
                    style I fill:#e8f5e8
            </div>
        </section>

        <section id="terminal-functions">
            <h2>4. 终端判断函数详解</h2>
            
            <h3>4.1 三种判断函数对比</h3>
            <div class="table-container">
                <table>
                    <tr>
                        <th>函数名</th>
                        <th>判断对象</th>
                        <th>判断条件</th>
                        <th>返回含义</th>
                        <th>主要用途</th>
                    </tr>
                    <tr>
                        <td><code>is_terminal()</code></td>
                        <td>MCTS节点</td>
                        <td>深度超限 OR 是有效叶子节点</td>
                        <td>是否停止MCTS扩展</td>
                        <td>控制搜索流程</td>
                    </tr>
                    <tr>
                        <td><code>reach_terminal_subquestion()</code></td>
                        <td>子问题内容</td>
                        <td>包含"Now we can answer" OR 包含原问题核心</td>
                        <td>子问题是否回到原问题</td>
                        <td>投票策略选择</td>
                    </tr>
                    <tr>
                        <td><code>reach_terminal_ost_step()</code></td>
                        <td>思考步骤内容</td>
                        <td>包含"answer is"</td>
                        <td>思考步骤是否得出答案</td>
                        <td>解决方案节点识别</td>
                    </tr>
                </table>
            </div>

            <h3>4.2 判断函数调用流程</h3>
            <div class="mermaid">
                graph TD
                    A["MCTS搜索过程"] --> B["is_terminal调用"]
                    B --> C{"深度超限?"}
                    C -->|是| D["返回True - 停止扩展"]
                    C -->|否| E["is_valid_leaf_node调用"]
                    E --> F{"DIRECT_ANSWER?"}
                    F -->|是| G["返回True - 有效终端"]
                    F -->|否| H{"SUBQUESTION?"}
                    H -->|是| I["reach_terminal_subquestion调用"]
                    H -->|否| J{"OST_STEP?"}
                    J -->|是| K["reach_terminal_ost_step调用"]
                    J -->|否| L["返回False - 继续搜索"]
                    
                    I --> M{"包含终端标识?"}
                    M -->|是| N["返回True - 终端子问题"]
                    M -->|否| O["返回False - 中间子问题"]
                    
                    K --> P{"包含answer_is?"}
                    P -->|是| Q["返回True - 终端思考"]
                    P -->|否| R["返回False - 中间思考"]
                    
                    style A fill:#e3f2fd
                    style B fill:#fff3e0
                    style I fill:#f3e5f5
                    style K fill:#e8f5e8
                    style D fill:#ffcdd2
                    style G fill:#ffcdd2
                    style N fill:#ffcdd2
                    style Q fill:#ffcdd2
            </div>

            <h3>4.3 判断函数实现细节</h3>
            <div class="function-detail">
                <h4>is_terminal() - MCTS搜索控制</h4>
                <div class="code-block">
def is_terminal(self):
    """
    判断节点是否为终端节点（MCTS终止条件）
    
    终端条件：
    1. 深度限制：节点深度达到最大允许深度
    2. 有效叶子节点：节点已经是有效的解决方案
    """
    return self.depth >= self.max_depth_allowed or self.is_valid_leaf_node()
                </div>
            </div>

            <div class="function-detail">
                <h4>reach_terminal_subquestion() - 子问题内容判断</h4>
                <div class="code-block">
def reach_terminal_subquestion(subquestion: str, user_question: str):
    """
    判断子问题是否为终端子问题
    
    终端子问题的判断条件：
    1. 子问题以"Now we can answer"开头，表示可以回答原问题
    2. 子问题包含原问题的核心部分，表示回到了原问题
    """
    if "Now we can answer" in subquestion:
        return True
    
    user_question_2nd_part = split_user_question(user_question)[1]
    if user_question_2nd_part.lower() in subquestion.lower():
        return True
    
    return False
                </div>
            </div>

            <div class="function-detail">
                <h4>reach_terminal_ost_step() - 思考步骤内容判断</h4>
                <div class="code-block">
def reach_terminal_ost_step(ost_step: str):
    """
    判断一步思考是否为终端步骤
    
    终端一步思考的判断条件：
    - 步骤内容包含"answer is"，表示已得出最终答案
    """
    return "answer is" in ost_step.lower()
                </div>
            </div>

            <h3>4.4 应用场景对比</h3>
            <div class="voting-strategy">
                <h4>🎯 关键区别总结</h4>
                <ul>
                    <li><strong>层次不同</strong>：
                        <ul>
                            <li><code>is_terminal()</code>：节点层面的判断</li>
                            <li><code>reach_terminal_*()</code>：内容层面的判断</li>
                        </ul>
                    </li>
                    <li><strong>目的不同</strong>：
                        <ul>
                            <li><code>is_terminal()</code>：控制MCTS搜索流程</li>
                            <li><code>reach_terminal_*()</code>：识别推理内容的完整性</li>
                        </ul>
                    </li>
                    <li><strong>影响不同</strong>：
                        <ul>
                            <li><code>is_terminal()</code>：决定是否继续扩展节点</li>
                            <li><code>reach_terminal_*()</code>：决定投票策略和解决方案识别</li>
                        </ul>
                    </li>
                </ul>
            </div>

            <h3>4.5 综合应用场景图</h3>
            <div class="mermaid">
                graph TD
                    A["MCTS搜索开始"] --> B["选择节点"]
                    B --> C["is_terminal判断"]
                    C -->|是| D["停止扩展，计算奖励"]
                    C -->|否| E["扩展节点"]
                    E --> F["生成子节点"]
                    F --> G["生成子问题"]
                    G --> H["reach_terminal_subquestion判断"]
                    H -->|是| I["使用32票投票"]
                    H -->|否| J["使用10票投票"]
                    
                    F --> K["生成思考步骤"]
                    K --> L["reach_terminal_ost_step判断"]
                    L -->|是| M["标记为解决方案节点"]
                    L -->|否| N["继续推理"]
                    
                    I --> O["创建SUBQUESTION节点"]
                    J --> O
                    M --> P["创建OST_STEP节点"]
                    N --> P
                    
                    O --> Q["节点加入搜索树"]
                    P --> Q
                    Q --> R["下一轮搜索"]
                    R --> B
                    
                    style C fill:#ffcdd2
                    style H fill:#fff3e0
                    style L fill:#f3e5f5
                    style I fill:#e8f5e8
                    style M fill:#e8f5e8
            </div>

            <div class="function-detail">
                <h4>📊 判断函数使用统计</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>函数</th>
                            <th>调用频率</th>
                            <th>性能影响</th>
                            <th>关键作用</th>
                        </tr>
                        <tr>
                            <td><code>is_terminal()</code></td>
                            <td>每个节点访问时</td>
                            <td>高</td>
                            <td>控制搜索深度和效率</td>
                        </tr>
                        <tr>
                            <td><code>reach_terminal_subquestion()</code></td>
                            <td>每个子问题生成时</td>
                            <td>中等</td>
                            <td>优化投票策略，提高答案质量</td>
                        </tr>
                        <tr>
                            <td><code>reach_terminal_ost_step()</code></td>
                            <td>每个思考步骤生成时</td>
                            <td>低</td>
                            <td>识别推理完整性</td>
                        </tr>
                    </table>
                </div>
            </div>
        </section>

        <section id="node-types">
            <h2>5. 节点类型与推理动作</h2>
            
            <h3>5.1 节点类型定义</h3>
            <div class="table-container">
                <table>
                    <tr>
                        <th>节点类型</th>
                        <th>描述</th>
                        <th>支持的动作</th>
                        <th>是否终端</th>
                    </tr>
                    <tr>
                        <td><span class="node-type">USER_QUESTION</span></td>
                        <td>用户原始问题节点（根节点）</td>
                        <td>A1, A2, A3, A5</td>
                        <td>否</td>
                    </tr>
                    <tr>
                        <td><span class="node-type">REPHRASED_USER_QUESTION</span></td>
                        <td>重新表述的用户问题节点</td>
                        <td>A1, A2, A3</td>
                        <td>否</td>
                    </tr>
                    <tr>
                        <td><span class="node-type">DIRECT_ANSWER</span></td>
                        <td>直接答案节点</td>
                        <td>无</td>
                        <td>是</td>
                    </tr>
                    <tr>
                        <td><span class="node-type">SUBQUESTION</span></td>
                        <td>子问题节点</td>
                        <td>A1, A2, A3, A4</td>
                        <td>条件性</td>
                    </tr>
                    <tr>
                        <td><span class="node-type">RE_SUBANSWER</span></td>
                        <td>重新回答子问题节点</td>
                        <td>A1, A2, A3</td>
                        <td>否</td>
                    </tr>
                    <tr>
                        <td><span class="node-type">OST_STEP</span></td>
                        <td>一步思考节点</td>
                        <td>A1, A2</td>
                        <td>条件性</td>
                    </tr>
                </table>
            </div>

            <h3>5.2 推理动作映射</h3>
            <div class="mermaid">
                graph LR
                    A[推理动作] --> A1[A1: 一步思考]
                    A --> A2[A2: 直接答案]
                    A --> A3[A3: 子问题分解]
                    A --> A4[A4: 重新回答]
                    A --> A5[A5: 问题重述]
                    
                    A1 --> A1F[generate_ost_step]
                    A2 --> A2F[generate_direct_answers]
                    A3 --> A3F[generate_subquestions]
                    A4 --> A4F[generate_re_subanswers]
                    A5 --> A5F[generate_rephrased_user_question]
                    
                    style A1 fill:#e3f2fd
                    style A2 fill:#e8f5e8
                    style A3 fill:#fff3e0
                    style A4 fill:#f3e5f5
                    style A5 fill:#fce4ec
            </div>

            <h3>5.3 终端条件判断</h3>
            <div class="terminal-condition">
                <h4>终端节点判断逻辑</h4>
                <ul>
                    <li><strong>深度限制</strong>：节点深度 >= max_depth_allowed</li>
                    <li><strong>有效叶子节点</strong>：
                        <ul>
                            <li>DIRECT_ANSWER：总是终端</li>
                            <li>SUBQUESTION：当reach_terminal_subquestion()返回True时</li>
                            <li>OST_STEP：当reach_terminal_ost_step()返回True时</li>
                        </ul>
                    </li>
                </ul>
            </div>
        </section>

        <section id="generator-functions">
            <h2>6. 生成器函数详解</h2>
            
            <h3>6.1 generate_direct_answers流程</h3>
            <div class="mermaid">
                graph TD
                    A[generate_direct_answers] --> B[构建提示信息]
                    B --> C[调用_fewshot_cot_answer_question]
                    C --> D[生成mcts_num_last_votes个候选]
                    D --> E[调用_get_most_likely_answer]
                    E --> F[投票选择最佳答案]
                    F --> G[返回答案和置信度]
                    
                    style A fill:#e3f2fd
                    style D fill:#fff3e0
                    style F fill:#f3e5f5
                    style G fill:#e8f5e8
            </div>

            <div class="voting-strategy">
                <h4>投票策略：mcts_num_last_votes (默认32)</h4>
                <p>直接答案是推理的最终结果，使用更多候选确保高可靠性</p>
            </div>

            <h3>6.2 generate_subquestions流程</h3>
            <div class="mermaid">
                graph TD
                    A[generate_subquestions] --> B[构建子问题生成上下文]
                    B --> C[生成num_subquestions个子问题]
                    C --> D[为每个子问题生成答案]
                    D --> E{子问题是否终端?}
                    E -->|是| F[使用mcts_num_last_votes]
                    E -->|否| G[使用num_votes]
                    F --> H[投票选择答案]
                    G --> H
                    H --> I{启用潜在分数?}
                    I -->|是| J[生成潜在答案评估]
                    I -->|否| K[跳过潜在评估]
                    J --> L[返回结果]
                    K --> L
                    
                    style A fill:#e3f2fd
                    style E fill:#fff3e0
                    style I fill:#f3e5f5
                    style L fill:#e8f5e8
            </div>

            <h3>6.3 投票数量决策逻辑</h3>
            <div class="code-block">
if reach_terminal_subquestion(subquestion=subquestion, user_question=user_question):
    # 终端子问题：使用更多候选确保质量
    num_return = self.mcts_num_last_votes  # 默认32
else:
    # 非终端子问题：使用较少候选平衡效率
    num_return = self.num_votes  # 默认10
            </div>

            <h3>6.4 其他生成器函数</h3>
            <div class="action-type">
                <h4>generate_re_subanswers (A4动作)</h4>
                <ul>
                    <li>定位最后一个子问题</li>
                    <li>使用num_votes重新生成答案</li>
                    <li>评估潜在分数（如果启用）</li>
                </ul>
            </div>

            <div class="action-type">
                <h4>generate_ost_step (A1动作)</h4>
                <ul>
                    <li>根据父节点类型构建思考上下文</li>
                    <li>生成num_a1_steps个思考步骤</li>
                    <li>评估每个步骤的潜在贡献</li>
                </ul>
            </div>

            <div class="action-type">
                <h4>generate_rephrased_user_question (A5动作)</h4>
                <ul>
                    <li>使用重述模板转换原问题</li>
                    <li>生成条件列表形式的问题</li>
                    <li>评估重述问题的潜在价值</li>
                </ul>
            </div>
        </section>

        <section id="voting-strategy">
            <h2>7. 投票策略机制</h2>
            
            <h3>7.1 投票参数对比</h3>
            <div class="table-container">
                <table>
                    <tr>
                        <th>参数</th>
                        <th>默认值</th>
                        <th>使用场景</th>
                        <th>计算开销</th>
                        <th>质量要求</th>
                    </tr>
                    <tr>
                        <td>num_votes</td>
                        <td>10</td>
                        <td>中间推理步骤</td>
                        <td>低</td>
                        <td>中等</td>
                    </tr>
                    <tr>
                        <td>mcts_num_last_votes</td>
                        <td>32</td>
                        <td>终端步骤</td>
                        <td>高</td>
                        <td>最高</td>
                    </tr>
                </table>
            </div>

            <h3>7.2 投票选择流程</h3>
            <div class="mermaid">
                graph TD
                    A[_get_most_likely_answer] --> B{候选数量 = 1?}
                    B -->|是| C[直接返回，置信度=1]
                    B -->|否| D[调用evaluator.find_most_confident_answer]
                    D --> E[提取每个候选的答案]
                    E --> F[按答案等价性聚类]
                    F --> G[统计每组答案频次]
                    G --> H{有先验权重?}
                    H -->|是| I[计算加权分数]
                    H -->|否| J[使用频次选择]
                    I --> K[选择分数最高的答案]
                    J --> L[选择频次最高的答案]
                    K --> M[返回答案和置信度]
                    L --> M
                    
                    style A fill:#e3f2fd
                    style D fill:#fff3e0
                    style H fill:#f3e5f5
                    style M fill:#e8f5e8
            </div>

            <h3>7.3 文本选择机制</h3>
            <div class="voting-strategy">
                <h4>双重选择策略</h4>
                <p><strong>基于频次的选择</strong>：选择频次最高答案组的第一个完整文本</p>
                <p><strong>基于权重的选择</strong>：选择加权分数最高的完整文本</p>
                <p>这确保了返回的不仅是正确答案，还包含高质量的推理过程</p>
            </div>
        </section>

        <section id="solution-selection">
            <h2>8. 解决方案选择</h2>
            
            <h3>8.1 解决方案查找流程</h3>
            <div class="mermaid">
                graph TD
                    A[stochastic_find_best_solution] --> B[find_valid_solution_nodes]
                    B --> C[递归遍历MCTS树]
                    C --> D[筛选有效解决方案节点]
                    D --> E{找到解决方案节点?}
                    E -->|否| F[返回None]
                    E -->|是| G[提取所有解决方案]
                    G --> H[调用evaluator投票选择]
                    H --> I{启用潜在分数?}
                    I -->|是| J[使用潜在分数权重]
                    I -->|否| K[使用标准投票]
                    J --> L[返回最佳解决方案]
                    K --> L
                    
                    style A fill:#e3f2fd
                    style D fill:#fff3e0
                    style H fill:#f3e5f5
                    style L fill:#e8f5e8
            </div>

            <h3>8.2 有效解决方案节点类型</h3>
            <div class="function-detail">
                <h4>is_valid_solution_node判断条件</h4>
                <ul>
                    <li><strong>DIRECT_ANSWER</strong>：总是有效解决方案</li>
                    <li><strong>SUBQUESTION</strong>：必须是终端子问题</li>
                    <li><strong>OST_STEP</strong>：必须是终端思考步骤</li>
                </ul>
            </div>

            <h3>8.3 潜在分数评估</h3>
            <div class="mermaid">
                graph TD
                    A[潜在分数评估] --> B[模拟完成推理过程]
                    B --> C[生成潜在答案列表]
                    C --> D[计算答案一致性]
                    D --> E[评估推理路径质量]
                    E --> F[生成潜在分数]
                    F --> G[用于节点选择权重]
                    
                    style A fill:#e3f2fd
                    style C fill:#fff3e0
                    style F fill:#f3e5f5
                    style G fill:#e8f5e8
            </div>
        </section>

        <section id="function-calls">
            <h2>9. 函数调用关系</h2>
            
            <h3>9.1 核心函数调用链</h3>
            <div class="mermaid">
                graph TD
                    A[search_for_answers] --> B[MCTS_Searcher.do_rollout]
                    B --> C[Reasoning_MCTS_Node.find_children]
                    C --> D[Reasoning_MCTS_Node._create_children]
                    D --> E[Generator.generate_*]
                    E --> F[IO_System.generate]
                    F --> G[_get_most_likely_answer]
                    G --> H[Evaluator.find_most_confident_answer]
                    H --> I[Evaluator.check_answers_equiv]
                    
                    B --> J[Reasoning_MCTS_Node.calculate_reward]
                    B --> K[MCTS_Searcher.backpropagate]
                    
                    A --> L[stochastic_find_best_solution]
                    L --> M[find_valid_solution_nodes]
                    L --> N[Evaluator.stochastic_find_most_confident_answer]
                    
                    style A fill:#e3f2fd
                    style E fill:#fff3e0
                    style H fill:#f3e5f5
                    style L fill:#e8f5e8
            </div>

            <h3>9.2 详细函数调用说明</h3>
            
            <div class="function-detail">
                <h4>search_for_answers主函数</h4>
                <p><strong>输入</strong>：args, user_question, question_id, gt_answer, generator</p>
                <p><strong>核心步骤</strong>：</p>
                <ul>
                    <li>初始化MCTS_Searcher</li>
                    <li>创建根节点Reasoning_MCTS_Node</li>
                    <li>执行num_rollouts轮MCTS搜索</li>
                    <li>每轮后选择当前最佳解决方案</li>
                    <li>保存搜索树和轨迹</li>
                </ul>
                <p><strong>输出</strong>：(模型解决方案列表, 最后rollout的ID, 所有解决方案列表)</p>
            </div>

            <div class="function-detail">
                <h4>MCTS_Searcher.do_rollout</h4>
                <p><strong>核心MCTS步骤</strong>：</p>
                <ul>
                    <li><strong>选择</strong>：使用UCT公式选择节点</li>
                    <li><strong>扩展</strong>：调用find_children生成子节点</li>
                    <li><strong>模拟</strong>：调用calculate_reward计算奖励</li>
                    <li><strong>反向传播</strong>：更新路径上所有节点的统计</li>
                </ul>
            </div>

            <div class="function-detail">
                <h4>Generator生成器函数组</h4>
                <p><strong>共同流程</strong>：</p>
                <ul>
                    <li>构建模型输入提示</li>
                    <li>调用IO_System.generate生成候选</li>
                    <li>使用投票机制选择最佳候选</li>
                    <li>生成潜在分数评估（如果启用）</li>
                    <li>返回结果和置信度</li>
                </ul>
            </div>

            <h3>9.3 关键工具函数</h3>
            <div class="table-container">
                <table>
                    <tr>
                        <th>函数名</th>
                        <th>功能</th>
                        <th>调用位置</th>
                    </tr>
                    <tr>
                        <td>reach_terminal_subquestion</td>
                        <td>判断子问题是否终端</td>
                        <td>投票数量决策、终端判断</td>
                    </tr>
                    <tr>
                        <td>reach_terminal_ost_step</td>
                        <td>判断思考步骤是否终端</td>
                        <td>解决方案节点识别</td>
                    </tr>
                    <tr>
                        <td>make_hint</td>
                        <td>生成推理提示</td>
                        <td>直接答案生成</td>
                    </tr>
                    <tr>
                        <td>make_response_prefix</td>
                        <td>生成响应前缀</td>
                        <td>潜在分数评估</td>
                    </tr>
                    <tr>
                        <td>concat_subqs_and_subas</td>
                        <td>拼接子问题和答案</td>
                        <td>子问题生成上下文</td>
                    </tr>
                </table>
            </div>
        </section>

        <section id="uct-calculation">
            <h2>10. UCT计算与反向传播详解</h2>
            
            <div class="function-detail">
                <h3>UCT公式详解</h3>
                <div class="code-block">
                    UCT(node) = Q(node)/N(node) + C × √(ln(N(parent))/N(node))
                    
                    其中：
                    - Q(node): 节点累积奖励值
                    - N(node): 节点访问次数
                    - N(parent): 父节点访问次数
                    - C: 探索权重参数 (mcts_exploration_weight)
                </div>
                
                <h4>UCT计算实例</h4>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>节点类型</th>
                            <th>Q值</th>
                            <th>N值</th>
                            <th>父节点N值</th>
                            <th>UCT值</th>
                            <th>说明</th>
                        </tr>
                        <tr>
                            <td>根节点</td>
                            <td>5.2</td>
                            <td>10</td>
                            <td>-</td>
                            <td>666</td>
                            <td>根节点特殊值</td>
                        </tr>
                        <tr>
                            <td>未探索节点</td>
                            <td>0.0</td>
                            <td>0</td>
                            <td>10</td>
                            <td>999</td>
                            <td>未探索节点优先级最高</td>
                        </tr>
                        <tr>
                            <td>已探索节点</td>
                            <td>2.4</td>
                            <td>3</td>
                            <td>10</td>
                            <td>0.8 + 2.0×√(ln(10)/3) = 2.16</td>
                            <td>正常UCT计算</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h3>反向传播机制</h3>
                <div class="mermaid">
                    graph TD
                        A[终端节点获得奖励] --> B[calculate_reward]
                        B --> C[沿路径向上传播]
                        C --> D[更新Q值: Q += reward]
                        D --> E[更新N值: N += 1]
                        E --> F[添加到explored_nodes]
                        F --> G[继续向父节点传播]
                        G --> H{是否到达根节点?}
                        H -->|否| D
                        H -->|是| I[反向传播完成]
                        
                        style A fill:#ffebee
                        style I fill:#e8f5e8
                </div>
                
                <h4>奖励值计算规则</h4>
                <div class="voting-strategy">
                    <ul>
                        <li><strong>有效叶子节点</strong>：返回node_value（置信度0-1）</li>
                        <li><strong>非有效叶子节点</strong>：返回0</li>
                        <li><strong>奖励标准化</strong>：min(0, reward_value) + 1 确保最小奖励为1</li>
                    </ul>
                </div>
            </div>
        </section>

        <section id="voting-mechanism">
            <h2>11. 投票机制详解</h2>
            
            <div class="function-detail">
                <h3>投票参数配置</h3>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>参数名</th>
                            <th>默认值</th>
                            <th>使用场景</th>
                            <th>投票目的</th>
                        </tr>
                        <tr>
                            <td>num_votes</td>
                            <td>10</td>
                            <td>中间节点投票</td>
                            <td>平衡质量和效率</td>
                        </tr>
                        <tr>
                            <td>mcts_num_last_votes</td>
                            <td>32</td>
                            <td>终端节点投票</td>
                            <td>确保最终答案质量</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h3>投票生效场景</h3>
                <div class="mermaid">
                    graph LR
                        A[模型生成多个候选] --> B[_get_most_likely_answer]
                        B --> C{候选数量}
                        C -->|1个| D[直接返回, 置信度=1.0]
                        C -->|多个| E[evaluator.find_most_confident_answer]
                        E --> F[答案聚类]
                        F --> G[频次统计]
                        G --> H[选择最高频次答案]
                        H --> I[返回最可能答案和置信度]
                        
                        style B fill:#e3f2fd
                        style E fill:#fff3e0
                        style I fill:#e8f5e8
                </div>
                
                <h4>投票选择算法</h4>
                <div class="code-block">
                    1. 答案提取：从每个候选中提取最终答案
                    2. 等价性判断：将相似答案归为同一组
                    3. 频次统计：计算每组答案的出现次数
                    4. 置信度计算：置信度 = 最高频次 / 总候选数
                    5. 文本选择：选择最高频次组的代表性文本
                </div>
            </div>

            <div class="function-detail">
                <h3>潜在分数投票</h3>
                <div class="voting-strategy">
                    <h4>潜在分数计算公式</h4>
                    <div class="code-block">
                        潜在分数 = ∏(深度i的一致性比例) for i in 所有深度
                        
                        深度i的一致性比例 = 与最终答案一致的潜在答案数 / 该深度的潜在答案总数
                        
                        示例：
                        - 深度1：["40", "42", "44"] → 1/3 (只有"42"一致)
                        - 深度2：["41", "42"] → 1/2 (只有"42"一致)
                        - 潜在分数 = (1/3) × (1/2) = 0.167
                    </div>
                    
                    <h4>加权投票机制</h4>
                    <div class="code-block">
                        加权分数 = 潜在分数 × (频次 / 总候选数)
                        
                        最终选择：选择加权分数最高的完整回答
                    </div>
                </div>
            </div>
        </section>

        <section id="node-values">
            <h2>12. 节点数值详解</h2>
            
            <div class="function-detail">
                <h3>节点统计信息</h3>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>统计项</th>
                            <th>符号</th>
                            <th>含义</th>
                            <th>计算方式</th>
                            <th>应用场景</th>
                        </tr>
                        <tr>
                            <td>累积奖励</td>
                            <td>Q</td>
                            <td>节点获得的总奖励</td>
                            <td>每次反向传播累加</td>
                            <td>UCT计算、节点评估</td>
                        </tr>
                        <tr>
                            <td>访问次数</td>
                            <td>N</td>
                            <td>节点被访问的次数</td>
                            <td>每次反向传播+1</td>
                            <td>UCT计算、统计分析</td>
                        </tr>
                        <tr>
                            <td>节点价值</td>
                            <td>V</td>
                            <td>节点的内在价值</td>
                            <td>投票置信度</td>
                            <td>奖励计算、质量评估</td>
                        </tr>
                        <tr>
                            <td>UCT值</td>
                            <td>UCT</td>
                            <td>节点选择优先级</td>
                            <td>UCT公式计算</td>
                            <td>节点选择、搜索引导</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h3>节点价值来源</h3>
                <div class="mermaid">
                    graph TD
                        A[生成多个候选] --> B[投票选择]
                        B --> C[计算置信度]
                        C --> D[设置node_value]
                        D --> E{节点类型}
                        E -->|DIRECT_ANSWER| F[直接答案置信度]
                        E -->|SUBQUESTION| G[子答案置信度]
                        E -->|RE_SUBANSWER| H[重新回答置信度]
                        E -->|OST_STEP| I[无node_value]
                        
                        F --> J[用于奖励计算]
                        G --> J
                        H --> J
                        I --> K[不参与奖励计算]
                        
                        style C fill:#e3f2fd
                        style J fill:#e8f5e8
                        style K fill:#ffebee
                </div>
            </div>
        </section>

        <section id="search-strategy">
            <h2>13. 搜索策略与权重调度</h2>
            
            <div class="function-detail">
                <h3>权重调度策略</h3>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>策略</th>
                            <th>公式</th>
                            <th>特点</th>
                            <th>适用场景</th>
                        </tr>
                        <tr>
                            <td>恒定权重 (const)</td>
                            <td>C = exploration_weight</td>
                            <td>权重不变</td>
                            <td>稳定探索</td>
                        </tr>
                        <tr>
                            <td>指数衰减 (exp)</td>
                            <td>C = exploration_weight × (0.1)^(t/T)</td>
                            <td>快速衰减</td>
                            <td>快速收敛</td>
                        </tr>
                        <tr>
                            <td>线性衰减 (lin)</td>
                            <td>C = exploration_weight × (1 - 0.9×t/T)</td>
                            <td>平滑衰减</td>
                            <td>平衡探索利用</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h3>搜索阶段分析</h3>
                <div class="mermaid">
                    graph LR
                        A[初期探索] --> B[中期平衡] --> C[后期利用]
                        
                        A1[高探索权重] --> A2[广度优先]
                        B1[中等权重] --> B2[深度探索]
                        C1[低探索权重] --> C2[最优路径]
                        
                        A --> A1
                        B --> B1
                        C --> C1
                        
                        style A fill:#e3f2fd
                        style B fill:#fff3e0
                        style C fill:#e8f5e8
                </div>
            </div>
        </section>

        <section id="performance-analysis">
            <h2>14. 性能分析与优化</h2>
            
            <div class="function-detail">
                <h3>API调用统计</h3>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>推理动作</th>
                            <th>每次调用数</th>
                            <th>调用频率</th>
                            <th>优化建议</th>
                        </tr>
                        <tr>
                            <td>A1 (一步思考)</td>
                            <td>num_a1_steps (3)</td>
                            <td>每个非终端节点</td>
                            <td>适中，平衡质量效率</td>
                        </tr>
                        <tr>
                            <td>A2 (直接答案)</td>
                            <td>mcts_num_last_votes (32)</td>
                            <td>每个节点</td>
                            <td>高成本，确保质量</td>
                        </tr>
                        <tr>
                            <td>A3 (子问题)</td>
                            <td>num_subquestions (3)</td>
                            <td>每个可扩展节点</td>
                            <td>适中，核心功能</td>
                        </tr>
                        <tr>
                            <td>A4 (重新回答)</td>
                            <td>num_votes (10)</td>
                            <td>子问题节点</td>
                            <td>低成本，多样性</td>
                        </tr>
                        <tr>
                            <td>A5 (问题重述)</td>
                            <td>1</td>
                            <td>根节点</td>
                            <td>最低成本</td>
                        </tr>
                    </table>
                </div>
            </div>

            <div class="function-detail">
                <h3>内存使用优化</h3>
                <div class="voting-strategy">
                    <h4>节点存储优化</h4>
                    <ul>
                        <li>使用defaultdict减少内存分配</li>
                        <li>延迟创建子节点直到需要时</li>
                        <li>共享不变的配置信息</li>
                    </ul>
                    
                    <h4>搜索树剪枝</h4>
                    <ul>
                        <li>设置最大深度限制 (max_depth_allowed)</li>
                        <li>早期终止低质量分支</li>
                        <li>清理不再使用的节点</li>
                    </ul>
                </div>
            </div>
        </section>

        <section id="debugging-tips">
            <h2>15. 调试与可视化</h2>
            
            <div class="function-detail">
                <h3>搜索树可视化</h3>
                <div class="code-block">
                    # 启用树结构保存
                    --save_tree
                    
                    # 输出文件格式
                    Question 0001 - Rollout 15.tree
                    
                    # 节点信息格式
                    [SQ-5: Q: 2.4; N: 3; V: 0.8; UCT: 2.16] Q: 子问题内容
                                                              A: 子答案内容
                </div>
            </div>

            <div class="function-detail">
                <h3>关键调试参数</h3>
                <div class="table-container">
                    <table>
                        <tr>
                            <th>参数</th>
                            <th>作用</th>
                            <th>调试场景</th>
                        </tr>
                        <tr>
                            <td>--verbose</td>
                            <td>详细输出</td>
                            <td>跟踪搜索过程</td>
                        </tr>
                        <tr>
                            <td>--save_tree</td>
                            <td>保存搜索树</td>
                            <td>分析树结构</td>
                        </tr>
                        <tr>
                            <td>--num_rollouts 1</td>
                            <td>单轮测试</td>
                            <td>快速验证</td>
                        </tr>
                    </table>
                </div>
            </div>
        </section>

        <section id="conclusion">
            <h2>16. 总结</h2>
            
            <div class="function-detail">
                <h3>rStar MCTS系统特点</h3>
                <ul>
                    <li><strong>多策略推理</strong>：支持5种推理动作的组合使用</li>
                    <li><strong>自适应搜索</strong>：通过UCT公式平衡探索与利用</li>
                    <li><strong>质量保证</strong>：多层次投票机制确保答案质量</li>
                    <li><strong>可扩展性</strong>：模块化设计支持新的推理策略</li>
                    <li><strong>可解释性</strong>：完整的推理轨迹记录</li>
                </ul>
            </div>

            <div class="function-detail">
                <h3>最佳实践建议</h3>
                <div class="voting-strategy">
                    <ol>
                        <li><strong>参数调优</strong>：根据问题复杂度调整rollout数量和深度限制</li>
                        <li><strong>权重设置</strong>：使用适当的探索权重平衡搜索效率</li>
                        <li><strong>投票配置</strong>：为不同阶段设置合适的投票数量</li>
                        <li><strong>性能监控</strong>：跟踪API调用和内存使用情况</li>
                        <li><strong>结果分析</strong>：利用搜索树可视化理解算法行为</li>
                    </ol>
                </div>
            </div>
        </section>
    </div>

    <script>
        // 初始化Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            themeVariables: {
                primaryColor: '#3498db',
                primaryTextColor: '#2c3e50',
                primaryBorderColor: '#2980b9',
                lineColor: '#34495e',
                secondaryColor: '#ecf0f1',
                tertiaryColor: '#ffffff'
            }
        });

        // 平滑滚动到锚点
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                const target = document.querySelector(this.getAttribute('href'));
                if (target) {
                    target.scrollIntoView({
                        behavior: 'smooth',
                        block: 'start'
                    });
                }
            });
        });

        // 添加返回顶部功能
        window.addEventListener('scroll', function() {
            const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
            if (scrollTop > 300) {
                if (!document.querySelector('.back-to-top')) {
                    const backToTop = document.createElement('button');
                    backToTop.className = 'back-to-top';
                    backToTop.innerHTML = '↑';
                    backToTop.style.cssText = `
                        position: fixed;
                        bottom: 20px;
                        right: 20px;
                        background: #3498db;
                        color: white;
                        border: none;
                        border-radius: 50%;
                        width: 50px;
                        height: 50px;
                        font-size: 20px;
                        cursor: pointer;
                        z-index: 1000;
                        transition: all 0.3s ease;
                    `;
                    backToTop.addEventListener('click', () => {
                        window.scrollTo({ top: 0, behavior: 'smooth' });
                    });
                    document.body.appendChild(backToTop);
                }
            } else {
                const backToTop = document.querySelector('.back-to-top');
                if (backToTop) {
                    backToTop.remove();
                }
            }
        });
    </script>
</body>
</html> 